home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / security / cops / cops_104 / perl / kuang < prev    next >
Encoding:
Text File  |  1992-03-10  |  15.0 KB  |  645 lines
  1. #!/bin/sh -- need to mention perl here to avoid recursion
  2. 'true' || eval 'exec perl -S $0 $argv:q';
  3. eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}'
  4. & eval 'exec /usr/users/df/bin/perl.sun4 -S $0 $argv:q'
  5.         if 0;
  6. # & eval 'exec /usr/local/bin/perl -S $0 $argv:q'
  7. #
  8. # kuang - rule based analysis of Unix security
  9. #
  10. # Perl version by Steve Romig of the CIS department, The Ohio State
  11. # University, October 1990. 
  12. # 
  13. # Based on the shell script version by Dan Farmer from his COPS
  14. # package, which in turn is based on a shell version by Robert
  15. # Baldwin. 
  16. #
  17. #-----------------------------------------------------------------------------
  18. # Players:
  19. #    romig    Steve Romig, romig@cis.ohio-state.edu
  20. #    tjt    Tim Tessin, tjt@cirrus.com
  21. #
  22. # History:
  23. # 4/25/91  tjt, romig    Various fixes to filewriters (better messages about 
  24. #            permission problems) and don't update the DBM cache 
  25. #            with local file info.
  26. # 11/1/90  romig    Major rewrite - generic lists, nuking get_entry 
  27. #            and put_entry, moved rules to separate file.
  28. #
  29.  
  30. #
  31. # Options
  32. #
  33. # -l        list uid's that can access the given target, directly
  34. #        or indirectly
  35. # -d        debug
  36. # -V         verbose
  37. #
  38. # -k file    load the list of known CO's
  39. # -f file    preload file information from the named file.
  40. # -p file    preload passwd info from the named file.
  41. # -Y        preload passwd info from ypcat + /etc/passwd
  42. # -g group    preload group info from the named file.
  43. # -G        preload group info from ypcat + /etc/group
  44. # 
  45. # NOTE:
  46. #   If you know where perl is and your system groks #!, put its
  47. # pathname at the top to make this a tad faster.
  48. #
  49. # the following magic is from the perl man page
  50. # and should work to get us to run with perl 
  51. # even if invoked as an sh or csh or foosh script.
  52. # notice we don't use full path cause we don't
  53. # know where the user has perl on their system.
  54. #
  55.  
  56. $options = "ldVk:p:g:f:YG";
  57. $usage = "usage: kuang [-l] [-d] [-v] [-k known] [-f file] [-Y] [-G] [-p passwd] [-g group] [u.username|g.groupname]\n";
  58.  
  59. $add_files_to_cache = 1;        # Whether to update the %files cache
  60.                     # with local file info or not.
  61.  
  62. #
  63. # Terminology:
  64. #
  65. #   An "op" is an operation, such as uid, gid, write, or replace. 
  66. #   'uid' means to gain access to some uid, 'gid' means to gain access 
  67. #   to some gid.  'write' and 'replace' refer to files - replace means
  68. #   that we can delete a file and replace it with a new one somehow
  69. #   (for example, if we could write the directory it is in).
  70. #
  71. #   An object is a uid, gid or pathname.  
  72. #
  73. #   A Controlling Operation (CO) is a (operation, object) pair
  74. #   represented as "op object": "uid 216" (become uid 216) or "replace
  75. #   /.rhosts" (replace file /.rhosts).  These are represented
  76. #   internally as "c value", where "c" is a character representing an
  77. #   operation (u for uid, g for gid, r for replace, w for write) and
  78. #   value is a uid, gid or pathname.
  79. #
  80. #   A plan is a chain of CO's that are connected to each other.  If
  81. #   /.login were writeable by uid 216, we might have a plan such as:
  82. #
  83. #    uid 216 => write /.login => uid 0
  84. #
  85. #   which means (in English) "if we can become uid 216, then write 
  86. #   /.login which gives you access to uid 0 (when root next logs in)."
  87. #   Plans are represented in several ways: as arrays:
  88. #
  89. #    ("u 0", "w /.login", "u 216")
  90. #
  91. #   Note that the order is reversed.  As a string:
  92. #
  93. #    "u 0\034w /.login\034u 216"
  94. #
  95. #   The target is the object that we are trying to gain (a uid, gid or
  96. #   file, typically u.root or some other UID).
  97. #
  98. # Data Structures
  99. #
  100. #   %known        An assocc array, indexed by CO.  This lists
  101. #            the COs that we already have access to.  If we
  102. #                       find a plan that leads from a CO in the known
  103. #                       list to the target, we've succeeded in
  104. #                       finding a major security flaw.  
  105. #
  106. #   @new        An array of plans that are to be evaluated in
  107. #            the next cycle. 
  108. #
  109. #   @old        An array of plans that we are currently
  110. #            evaluating. 
  111. #
  112. #   %beendone        An assoc array that lists the plans that have
  113. #            already been tried.  Used to prevent loops.
  114. #
  115. #   @accessible        An array of the uids that can reach the
  116. #            target. 
  117. #
  118. #   %files        An assoc array, indexed by file name, contains
  119. #            cached file info.  value is of form "uid gid
  120. #            mode". 
  121. #
  122. # From pwgrid:
  123. #
  124. #   %uname2shell    Assoc array, indexed by user name, values are
  125. #            shells. 
  126. #
  127. #   %uname2dir        Assoc array, indexed by user name, values are
  128. #            home directories.
  129. #
  130. #   %uname2uid        Assoc array, indexed by name, values are uids.
  131. #            
  132. #   %uid2names        Assoc array, indexed by uid, value is list of
  133. #            user names with that uid, in form "name name
  134. #            name...". 
  135. #
  136. #   %gid2members    Assoc array, indexed by gid, value is list of
  137. #            group members (user names).
  138. #
  139. #   %gname2gid        Assoc array, indexed by group name, values are
  140. #            matching gids.
  141. #
  142. #   %gid2names        Assoc array, indexed by gid, values are
  143. #            matching group names.
  144. #
  145.  
  146. do 'yagrip.pl' ||
  147.   die "can't do yagrip.pl";
  148.  
  149. # do 'pwgrid.pl' ||
  150. #   die "can't do pwgrid.pl";
  151. do 'pass.cache.pl' ||
  152.   die "can't do pass.cache.pl";
  153.  
  154. do 'rules.pl' ||
  155.   die "can't do rules.pl";
  156.  
  157.  
  158. #
  159. # Turns a string of the form "operation value" or "value" into
  160. # standard "CO" form ("operation value").  Converts user or group
  161. # names into corresponding uid and gid values. 
  162. #
  163. # Returns nothing if it isn't parseable.
  164. #
  165.  
  166. sub canonicalize {
  167.     local($string) = @_;
  168.     local($op, $value);
  169.  
  170.     if ($string =~ /^([ugrw]) ([^ \t\n]+)$/) { # of form "op value"
  171.     $op = $1;
  172.     $value = $2;
  173.     } elsif ($string =~ /^[^ \t\n]+$/) {       # of form "value"
  174.         $value = $string;
  175.     $op = "u";
  176.     } else {
  177.     return();
  178.     }
  179.  
  180.     if ($op eq "u" && $value =~ /^[^0-9]+$/) { # user name, not ID
  181.         if (defined($uname2uid{$value})) {
  182.         $value = $uname2uid{$value};
  183.     } else {
  184.         printf(stderr "There's no user named '%s'.\n", $value);
  185.         return();
  186.     }
  187.     } elsif ($op eq "g" && $value =~/^[^0-9]+$/) {
  188.     if (defined($gname2gid{$value})) {
  189.         $value = $gname2gid{$value};
  190.     } else {
  191.         printf(stderr "There's no group named '%s'.\n", $value);
  192.         return();
  193.     }
  194.     }
  195.  
  196.     return($op, $value);
  197. }
  198.  
  199.  
  200. #
  201. # Preload file information from a text file or DBM database.  
  202. # If $opt_f.dir exists, then we just shadow %files from a DBM
  203. # database.  Otherwise, open the file and read the entries into 
  204. # %files.  
  205. #
  206. # $add_files_to_cache is set to 0 if we get the info from 
  207. # DBM since we wouldn't want to pollute update our DBM cache
  208. # with local file info which wouldn't apply to other hosts.
  209. #
  210.  
  211. sub preload_file_info {
  212.     local($count, $f_type, $f_uid, $f_gid, $f_mode, $f_name);
  213.  
  214.     if (defined($opt_d)) {
  215.     printf("loading file info...\n");
  216.     }
  217.  
  218.     if (-f "$opt_f.dir") {
  219.     $add_files_to_cache = 0;
  220.  
  221.     dbmopen(files, $opt_f, 0644) ||
  222.       die sprintf("can't open DBM file '%s'", $opt_f);
  223.     } else {
  224.     open(FILEDATA, $opt_f) || 
  225.       die sprintf("kuang: can't open '%s'", $opt_f);
  226.  
  227.     $count = 0;
  228.     while (<FILEDATA>) {
  229.         $count++;
  230.  
  231.         chop;
  232.         ($f_type, $f_uid, $f_gid, $f_mode, $f_name) = split;
  233.         
  234.         if ($count % 1000 == 0) {
  235.         printf("line $count, reading entry for $f_name\n");
  236.         }
  237.         $files{$f_name} = join(' ', $f_uid, $f_gid, $f_mode);
  238.     }
  239.  
  240.     close(FILEDATA);
  241.     }
  242. }
  243.  
  244. #
  245. # Preload the known information.  Reads data from a file, 1 entry per line,
  246. # each entry is a CO that we "know" can be used.
  247. #
  248.  
  249. sub preload_known_info {
  250.     local($file_name) = @_;
  251.     local($op, $value, $co);
  252.  
  253.     open(FILE, $file_name) ||
  254.       die sprintf("kuang: can't open '%s'", $file_name);
  255.  
  256.   known_loop:
  257.     while (<FILE>) {
  258.     chop;
  259.     if ((($op, $value) = &canonicalize($_)) == 2) {
  260.         $co = sprintf("%s %s", $op, $value);
  261.         $known{$co} = 1;
  262.     } else {
  263.         printf(stderr "kuang: invalid entry in known list: line %d '%s'.\n",
  264.            $.,
  265.            $_);
  266.     }
  267.     }
  268.  
  269.     close(FILE);
  270. }
  271.     
  272.  
  273. #
  274. # Do various initialization type things.
  275. #
  276.  
  277. sub init_kuang {
  278.     local($which, $name, $uid, $gid);
  279.     local($op, $value, $co);
  280.  
  281.     #
  282.     # Deal with args...
  283.     #
  284.  
  285.     &getopt($options) ||
  286.       die $usage;
  287.  
  288.     if ($#ARGV == -1) {
  289.     push(@ARGV, "u root");
  290.     }
  291.  
  292.     #
  293.     # Preload anything...
  294.     #
  295.     if (defined($opt_f)) {
  296.     &preload_file_info();
  297.     }
  298.  
  299.     if (defined($opt_d)) {
  300.     printf("load passwd info...\n");
  301.     }
  302.  
  303.     if (defined($opt_p)) {
  304.     if (defined($opt_Y)) {
  305.         printf(stderr "You can only specify one of -p or -P, not both.\n");
  306.         exit(1);
  307.     }
  308.  
  309.     &load_passwd_info(0, $opt_p);
  310.     } elsif (defined($opt_Y)) {
  311.     &load_passwd_info(0);
  312.     } else {
  313.     &load_passwd_info(1);
  314.     }
  315.  
  316.     if (defined($opt_d)) {
  317.     printf("load group info...\n");
  318.     }
  319.  
  320.     if (defined($opt_g)) {
  321.     if (defined($opt_G)) {
  322.         printf(stderr "You can only specify one of -g or -G, not both.\n");
  323.         exit(1);
  324.     }
  325.  
  326.     &load_group_info(0, $opt_g);
  327.     } elsif (defined($opt_G)) {
  328.     &load_group_info(0);
  329.     } else {
  330.     &load_group_info(1);
  331.     }
  332.  
  333.     #
  334.     # Need some of the password and group stuff.  Suck in passwd and 
  335.     # group info, store by uid and gid in an associative array of strings
  336.     # which consist of fields corresponding to the passwd and group file 
  337.     # entries (and what the heck, we'll use : as a delimiter also...:-)
  338.     #
  339.     $uname2shell{"OTHER"} = "";
  340.     $uname2dir{"OTHER"} = "";
  341.     $uname2uid{"OTHER"} = -1;
  342.     $uid2names{-1} = "OTHER";
  343.  
  344.     $known{"u -1"} = 1;        # We can access uid OTHER
  345.  
  346.     if (defined($opt_k)) {
  347.     &preload_known_info($opt_k);
  348.     }
  349.  
  350.     #
  351.     # Create the target list from the remaining (non-option) args...
  352.     #
  353.     while ($#ARGV >= 0) {
  354.     $elt = pop(@ARGV);
  355.     if ((($op, $value) = &canonicalize($elt)) == 2) {
  356.         $co = sprintf("%s %s", $op, $value);
  357.         push(@targets, $co);
  358.     } else {
  359.         printf(stderr "target '%s' isn't of correct form\n", $elt);
  360.     }
  361.     }
  362. }
  363.  
  364.  
  365. #
  366. # Call this to set things up for a new target.  Resets old, new, beendone 
  367. # and accessible.  
  368. #
  369. sub set_target {
  370.     local($target) = @_;
  371.  
  372.     @old = ();
  373.     @new = ();
  374.     %beendone = ();
  375.     @accessible = ();
  376. # fixme: reset known?
  377.  
  378.     if ($target =~ /^([ugrw]) ([^ \t]+)$/) {
  379.     &addto($1, $2);
  380.     return(0);
  381.     } else {
  382.     printf(stderr "kuang: bad target '%s'\n", $target);
  383.     return(1);
  384.     }
  385. }
  386.  
  387. #
  388. # Break a CO into an (operation, value) pair and return it.  If it
  389. # isn't in "operation value" form, return ().
  390. #
  391. sub breakup {
  392.     local($co) = @_;
  393.     local($operation, $value);
  394.  
  395.     if ($co =~ /^([ugrw]) ([^ \t]+)$/) {
  396.     $operation = $1;
  397.     $value = $2;
  398.     } else {
  399.     printf(stderr "Yowza, breakup failed on '%s'\n",
  400.         $co);
  401.     exit(1);
  402.     }
  403.  
  404.     return($operation, $value);
  405. }
  406.  
  407. #
  408. # Get the writers of the named file - return as (UID, GID, OTHER)
  409. # triplet.  Owner can always write, since he can chmod the file if he
  410. # wants. 
  411. #
  412. # (fixme) are there any problems in this sort of builtin rule?  should
  413. # we make this knowledge more explicit?
  414. #
  415. sub filewriters {
  416.     local($name) = @_;
  417.     local($tmp, $mode, $uid, $gid, $other);
  418.     
  419.     #
  420.     # Check the file cache - avoid disk lookups for performance and 
  421.     # to avoid shadows...
  422.     #
  423.     if (defined($files{$name})) {
  424.     $cache_hit++;
  425.     
  426.     ($uid, $gid, $mode, $tmp) = split(/ /, $files{$name});
  427.     } else {
  428.     $cache_miss++;
  429.  
  430.     unless (-e $name) {
  431.         if ($add_files_to_cache) {
  432.         $files{$name} = "";
  433.         }
  434.         # ENOTDIR = 20 
  435.         ($! == 20) && print "Warning: Illegal Path: '$name'\n";
  436.         # EACCES = 13
  437.         ($! == 13) && print "Warning: Permission Denied: '$name'\n";
  438.         # all values are returned "" here.
  439.         return;
  440.     }
  441.  
  442.     ($tmp,$tmp,$mode,$tmp,$uid,$gid) = stat(_);
  443.     if ($add_files_to_cache) {
  444.         $files{$name} = join(' ', "$uid", "$gid", "$mode");
  445.     }
  446.     }
  447.  
  448.     if (($mode & 020) != 020) {
  449.     $gid = "";
  450.     }
  451.     
  452.     if (($mode & 02) == 02) {
  453.     $other = 1;
  454.     } else {
  455.     $other = 0;
  456.     }
  457.  
  458.     return($uid, $gid, $other);
  459. }
  460.  
  461.  
  462. sub ascii_plan {
  463.     local(@plan) = @_;
  464.     local($op, $value, $result);
  465.  
  466.     for ($i = $#plan; $i >= 0; $i--) {
  467.     ($op, $value) = &breakup($plan[$i]);
  468.  
  469.       case: 
  470.     {
  471.         if ($op eq "g") {
  472.         $op = "grant gid";
  473.         last case;
  474.         }
  475.  
  476.         if ($op eq "u") {
  477.         $op = "grant uid";
  478.         last case;
  479.         }
  480.  
  481.         if ($op eq "r") {
  482.         $op = "replace";
  483.         last case;
  484.         }
  485.  
  486.         if ($op eq "w") {
  487.         $op = "write";
  488.         last case;
  489.         }
  490.  
  491.         printf(stderr "Bad op '%s' in plan '%s'\n",
  492.            $op,
  493.            join(';', @plan));
  494.         last case;
  495.     }
  496.  
  497.     $result .= "$op $value ";
  498.     }
  499.  
  500.     return($result);
  501. }
  502.  
  503. #
  504. # Add a plan to the list of plans to check out.
  505. #
  506. sub addto {
  507.     local($op, $value, @plan) = @_;
  508.     local($co);
  509.  
  510.     $co = sprintf("%s %s",
  511.           $op,
  512.           $value);
  513.  
  514.     #
  515.     # See if the op and value is "uid root" - if so, and if the @plan 
  516.     # isn't empty, then don't bother checking - if the target isn't root, 
  517.     # its silly to pursue plans that require becoming root since if we can 
  518.     # become root, we can become anything.  If the target is root, then 
  519.     # this would be a loop anyway.
  520.     #
  521.     if ($op eq "u" && $value eq "0" && $#plan >= 0) {
  522.     if (defined($opt_d)) {
  523.         printf("addto: aborted root plan '%s'\n",
  524.            &ascii_plan(@plan, $co));
  525.     }
  526.     return;
  527.     }
  528.  
  529.     #
  530.     # See whether there's an entry for $co in the known list.
  531.     # If so - success, we've found a suitable breakin plan.
  532.     #
  533.     # Yes, we want to check to see whether the whole Controlling Operation 
  534.     # is one that is known to us, rather than just the object.  I
  535.     # might have a hole that allows me to "replace /bin/foo" which is
  536.     # somewhat different than "write /bin/foo"  
  537.     #
  538.     if (! defined($opt_l) && defined($known{$co})) {
  539.     printf("Success! %s\n",
  540.            &ascii_plan(@plan, $co));
  541.     }
  542.  
  543.     #
  544.     # Check for loops -- if the new CO is part of the plan that we're
  545.     # adding it to, this is a loop.
  546.     #
  547.     foreach $entry (@plan) {
  548.     if ($entry eq $co) {
  549.         if (defined($opt_d)) {
  550.         printf("addto: aborted loop in plan '%s'\n",
  551.                &ascii_plan(@plan, $co));
  552.         }
  553.         return;
  554.     }
  555.     }
  556.  
  557.     #
  558.     # Add this CO to the plan array...
  559.     #
  560.     push(@plan, $co);
  561.  
  562.     #
  563.     # Make an ascii version of sorts...
  564.     #
  565.     $text_plan = join($;, @plan);
  566.  
  567.     #
  568.     # Check to see if the new plan has been done.
  569.     #
  570.     if (defined($beendone{$text_plan})) {
  571.     if (defined($opt_d)) {
  572.         printf("addto: plan's been done - '%s'\n",
  573.            &ascii_plan(@plan));
  574.     }
  575.     return;
  576.     }
  577.  
  578.     #
  579.     # If we made it this far, its a new plan and isn't a loop.  
  580.     #
  581.  
  582.     #
  583.     # Add to the beendone list...
  584.     #
  585.     $beendone{$text_plan} = 1;
  586.  
  587.     #
  588.     # Add to new plan list...
  589.     #
  590.     push(@new, $text_plan);
  591.  
  592.     if (defined($opt_V)) {
  593.     printf("addto: %s\n", 
  594.            &ascii_plan(@plan));
  595.     }
  596.  
  597.     #
  598.     # If this is a uid goal, then add the plan to the accessible list.
  599.     #
  600.     if ($op eq "u" && $value ne "0" && defined($opt_l)) {
  601.     push(@accessible, $value);
  602.     }
  603. }
  604.  
  605. #
  606. #----------------------------------------------------------------------
  607. #Main program follows...initialize and loop till we're done.
  608. #
  609.  
  610. &init_kuang();
  611.  
  612. target_loop:
  613. foreach $target (@targets) {
  614.     if (&set_target($target)) {
  615.     next target_loop;
  616.     }
  617.  
  618.     while ($#new >= 0) {
  619.     @old = @new;
  620.     @new = ();
  621.  
  622.     foreach $t_plan (@old) {
  623.         @plan = split(/\034/, $t_plan);
  624.         ($op, $value) = &breakup($plan[$#plan]);
  625.  
  626.         &apply_rules($op, $value, @plan);
  627.     }
  628.     }
  629.  
  630.     if (defined($opt_l)) {
  631.     foreach $elt (@accessible) {
  632.         printf("$elt\n");
  633.     }
  634.     }
  635. }
  636.  
  637. if (defined($opt_d)) {
  638.     printf("File info cache hit/access ratio: %g\n", 
  639.            ($cache_hit + $cache_miss > 0) 
  640.             ? $cache_hit / ($cache_hit + $cache_miss)
  641.             : 0.0);
  642. }
  643.  
  644. 1;
  645.